home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / share / hplip / base / tui.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2009-10-28  |  13KB  |  421 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import sys
  5. import re
  6. from g import *
  7. import pexpect
  8. import utils
  9.  
  10. def enter_yes_no(question, default_value = 'y', choice_prompt = None):
  11.     if type(default_value) == type(''):
  12.         if default_value == 'y':
  13.             default_value = True
  14.         else:
  15.             default_value = False
  16.     
  17.     if choice_prompt is None:
  18.         if default_value:
  19.             question += ' (y=yes*, n=no, q=quit) ? '
  20.         else:
  21.             question += ' (y=yes, n=no*, q=quit) ? '
  22.     else:
  23.         question += choice_prompt
  24.     while True:
  25.         
  26.         try:
  27.             user_input = raw_input(log.bold(question)).lower().strip()
  28.         except EOFError:
  29.             continue
  30.  
  31.         if not user_input:
  32.             return (True, default_value)
  33.         if user_input == 'n':
  34.             return (True, False)
  35.         if user_input == 'y':
  36.             return (True, True)
  37.         if user_input in ('q', 'c'):
  38.             return (False, default_value)
  39.         log.error("Please press <enter> or enter 'y', 'n', or 'q'.")
  40.         continue
  41.         user_input in ('q', 'c')
  42.  
  43.  
  44. def enter_range(question, min_value, max_value, default_value = None):
  45.     while True:
  46.         
  47.         try:
  48.             user_input = raw_input(log.bold(question)).lower().strip()
  49.         except EOFError:
  50.             continue
  51.  
  52.         if not user_input:
  53.             if default_value is not None:
  54.                 return (True, default_value)
  55.         
  56.         if user_input == 'q':
  57.             return (False, default_value)
  58.         
  59.         try:
  60.             value_int = int(user_input)
  61.         except ValueError:
  62.             user_input == 'q'
  63.             user_input == 'q'
  64.             log.error('Please enter a number between %d and %d, or "q" to quit.' % (min_value, max_value))
  65.             continue
  66.         except:
  67.             user_input == 'q'
  68.  
  69.         if value_int < min_value or value_int > max_value:
  70.             log.error('Please enter a number between %d and %d, or "q" to quit.' % (min_value, max_value))
  71.             continue
  72.         
  73.         return (True, value_int)
  74.  
  75.  
  76. def enter_choice(question, choices, default_value = None):
  77.     if 'q' not in choices:
  78.         choices.append('q')
  79.     
  80.     for x in choices:
  81.         continue
  82.         []([] % (_[1](_[1]["'%s'" % x]), default_value))
  83.         continue
  84.         ', '.join
  85.  
  86.  
  87. def title(text):
  88.     log.info('')
  89.     log.info('')
  90.     log.info(log.bold(text))
  91.     log.info(log.bold('-' * len(text)))
  92.  
  93.  
  94. def header(text):
  95.     c = len(text)
  96.     log.info('')
  97.     log.info('-' * (c + 4))
  98.     log.info('| ' + text + ' |')
  99.     log.info('-' * (c + 4))
  100.     log.info('')
  101.  
  102.  
  103. def load_paper_prompt():
  104.     return continue_prompt('A page will be printed.\nPlease load plain paper into the printer.')
  105.  
  106.  
  107. def load_scanner_for_align_prompt():
  108.     return continue_prompt("Load the alignment page on the scanner bed and push the 'Scan' or 'Enter' button on the printer to complete the alignment.")
  109.  
  110.  
  111. def load_photo_paper_prompt():
  112.     return continue_prompt('A page will be printed.\nPlease load HP Advanced Photo Paper - Glossy into the printer.')
  113.  
  114.  
  115. def continue_prompt(prompt = ''):
  116.     while True:
  117.         
  118.         try:
  119.             x = raw_input(log.bold(prompt + " Press <enter> to continue or 'q' to quit: ")).lower().strip()
  120.         except EOFError:
  121.             continue
  122.  
  123.         if not x:
  124.             return True
  125.         if x == 'q':
  126.             return False
  127.         log.error("Please press <enter> or enter 'q' to quit.")
  128.         continue
  129.         x == 'q'
  130.  
  131.  
  132. def enter_regex(regex, prompt, pattern, default_value = None):
  133.     re_obj = re.compile(regex)
  134.     while True:
  135.         
  136.         try:
  137.             x = raw_input(log.bold(prompt))
  138.         except EOFError:
  139.             continue
  140.  
  141.         if not x and default_value is not None:
  142.             return (default_value, x)
  143.         if x == 'q':
  144.             return (False, default_value)
  145.         match = re_obj.search(x)
  146.         return (True, x)
  147.         None if not match else default_value is not None
  148.  
  149.  
  150. def ttysize():
  151.     
  152.     try:
  153.         import commands as commands
  154.         ln1 = commands.getoutput('stty -a').splitlines()[0]
  155.         vals = {
  156.             'rows': None,
  157.             'columns': None }
  158.         for ph in ln1.split(';'):
  159.             x = ph.split()
  160.             if len(x) == 2:
  161.                 vals[x[0]] = x[1]
  162.                 vals[x[1]] = x[0]
  163.                 continue
  164.         
  165.         return (int(vals['rows']), int(vals['columns']))
  166.     except TypeError:
  167.         return (40, 64)
  168.  
  169.  
  170.  
  171. class ProgressMeter(object):
  172.     
  173.     def __init__(self, prompt = 'Progress:'):
  174.         self.progress = 0
  175.         self.prompt = prompt
  176.         self.prev_length = 0
  177.         self.spinner = '\\|/-\\|/-*'
  178.         self.spinner_pos = 0
  179.         self.max_size = ttysize()[1] - len(prompt) - 25
  180.         self.update(0)
  181.  
  182.     
  183.     def update(self, progress, msg = ''):
  184.         self.progress = progress
  185.         x = self.progress * self.max_size / 100
  186.         if x > self.max_size:
  187.             x = self.max_size
  188.         
  189.         if self.progress >= 100:
  190.             self.spinner_pos = 8
  191.             self.progress = 100
  192.         
  193.         sys.stdout.write('\x08' * self.prev_length)
  194.         y = '%s [%s%s%s] %d%%  %s   ' % (self.prompt, '*' * (x - 1), self.spinner[self.spinner_pos], ' ' * (self.max_size - x), self.progress, msg)
  195.         sys.stdout.write(y)
  196.         sys.stdout.flush()
  197.         self.prev_length = len(y)
  198.         self.spinner_pos = (self.spinner_pos + 1) % 8
  199.  
  200.  
  201.  
  202. class Formatter(object):
  203.     
  204.     def __init__(self, margin = 2, header = None, min_widths = None, max_widths = None):
  205.         self.margin = margin
  206.         self.header = header
  207.         self.rows = []
  208.         self.max_widths = max_widths
  209.         self.min_widths = min_widths
  210.  
  211.     
  212.     def add(self, row_data):
  213.         self.rows.append(row_data)
  214.  
  215.     
  216.     def output(self):
  217.         if self.rows:
  218.             num_cols = len(self.rows[0])
  219.             for r in self.rows:
  220.                 if len(r) != num_cols:
  221.                     log.error('Invalid number of items in row: %s' % r)
  222.                     return None
  223.             
  224.             if len(self.header) != num_cols:
  225.                 log.error('Invalid number of items in header.')
  226.             
  227.             min_calc_widths = []
  228.             for c in self.header:
  229.                 header_parts = c.split(' ')
  230.                 max_width = 0
  231.                 for x in header_parts:
  232.                     max_width = max(max_width, len(x))
  233.                 
  234.                 min_calc_widths.append(max_width)
  235.             
  236.             max_calc_widths = []
  237.             for x, c in enumerate(self.header):
  238.                 max_width = 0
  239.                 for r in self.rows:
  240.                     max_width = max(max_width, len(r[x]))
  241.                 
  242.                 max_calc_widths.append(max_width)
  243.             
  244.             max_screen_width = None
  245.             if self.max_widths is None:
  246.                 max_screen_width = ttysize()[1]
  247.                 def_max = 8 * (max_screen_width / num_cols) / 10
  248.                 self.max_widths = []
  249.                 for c in self.header:
  250.                     self.max_widths.append(def_max)
  251.                 
  252.             elif len(self.max_widths) != num_cols:
  253.                 log.error('Invalid number of items in max col widths.')
  254.             
  255.             if self.min_widths is None:
  256.                 if max_screen_width is None:
  257.                     max_screen_width = ttysize()[1]
  258.                 
  259.                 def_min = 4 * (max_screen_width / num_cols) / 10
  260.                 self.min_widths = []
  261.                 for c in self.header:
  262.                     self.min_widths.append(def_min)
  263.                 
  264.             elif len(self.min_widths) != num_cols:
  265.                 log.error('Invalid number of items in min col widths.')
  266.             
  267.             col_widths = []
  268.             formats = []
  269.             for m1, m2, m3, m4 in zip(self.min_widths, min_calc_widths, self.max_widths, max_calc_widths):
  270.                 col_width = max(max(m1, m2), min(m3, m4))
  271.                 col_widths.append(col_width)
  272.                 formats.append({
  273.                     'width': col_width,
  274.                     'margin': self.margin })
  275.             
  276.             formatter = utils.TextFormatter(tuple(formats))
  277.             log.info(formatter.compose(self.header))
  278.             sep = []
  279.             for c in col_widths:
  280.                 sep.append('-' * c)
  281.             
  282.             log.info(formatter.compose(tuple(sep)))
  283.             for r in self.rows:
  284.                 log.info(formatter.compose(r))
  285.             
  286.         else:
  287.             log.error('No data rows')
  288.  
  289.  
  290. ALIGN_LEFT = 0
  291. ALIGN_CENTER = 1
  292. ALIGN_RIGHT = 2
  293.  
  294. def align(line, width = 70, alignment = ALIGN_LEFT):
  295.     space = width - len(line)
  296.     if alignment == ALIGN_CENTER:
  297.         return ' ' * (space / 2) + line + ' ' * (space / 2 + space % 2)
  298.     if alignment == ALIGN_RIGHT:
  299.         return ' ' * space + line
  300.     return line + ' ' * space
  301.  
  302.  
  303. def format_paragraph(paragraph, width = None, alignment = ALIGN_LEFT):
  304.     if width is None:
  305.         width = ttysize()[1]
  306.     
  307.     result = []
  308.     words = paragraph.split()
  309.     
  310.     try:
  311.         current = words[0]
  312.         words = words[1:]
  313.     except IndexError:
  314.         return [
  315.             paragraph]
  316.  
  317.     for word in words:
  318.         increment = 1 + len(word)
  319.         if len(current) + increment > width:
  320.             result.append(align(current, width, alignment))
  321.             current = word
  322.             continue
  323.         current = current + ' ' + word
  324.     
  325.     result.append(align(current, width, alignment))
  326.     return result
  327.  
  328.  
  329. def printer_table(printers):
  330.     header('SELECT PRINTER')
  331.     last_used_printer_name = user_conf.get('last_used', 'printer_name')
  332.     ret = None
  333.     table = Formatter(header = ('Num', 'CUPS Printer'), max_widths = (8, 100), min_widths = (8, 20))
  334.     default_index = None
  335.     for x, _ in enumerate(printers):
  336.         if last_used_printer_name == printers[x]:
  337.             table.add((str(x) + '*', printers[x]))
  338.             default_index = x
  339.             continue
  340.         table.add((str(x), printers[x]))
  341.     
  342.     table.output()
  343.     if default_index is not None:
  344.         (ok, i) = enter_range('\nEnter number 0...%d for printer (q=quit, <enter>=default: *%d) ?' % (x, default_index), 0, x, default_index)
  345.     else:
  346.         (ok, i) = enter_range('\nEnter number 0...%d for printer (q=quit) ?' % x, 0, x)
  347.     if ok:
  348.         ret = printers[i]
  349.     
  350.     return ret
  351.  
  352.  
  353. def device_table(devices, scan_flag = False):
  354.     header('SELECT DEVICE')
  355.     last_used_device_uri = user_conf.get('last_used', 'device_uri')
  356.     ret = None
  357.     if scan_flag:
  358.         table = Formatter(header = ('Num', 'Scan device URI'), max_widths = (8, 100), min_widths = (8, 12))
  359.     else:
  360.         table = Formatter(header = ('Num', 'Device URI', 'CUPS Printer(s)'), max_widths = (8, 100, 100), min_widths = (8, 12, 12))
  361.     default_index = None
  362.     device_index = { }
  363.     for x, d in enumerate(devices):
  364.         device_index[x] = d
  365.         if last_used_device_uri == d:
  366.             if scan_flag:
  367.                 table.add((str(x) + '*', d))
  368.             else:
  369.                 table.add((str(x) + '*', d, ','.join(devices[d])))
  370.             default_index = x
  371.             continue
  372.         if scan_flag:
  373.             table.add((str(x), d))
  374.             continue
  375.         table.add((str(x), d, ','.join(devices[d])))
  376.     
  377.     table.output()
  378.     if default_index is not None:
  379.         (ok, i) = enter_range('\nEnter number 0...%d for device (q=quit, <enter>=default: %d*) ?' % (x, default_index), 0, x, default_index)
  380.     else:
  381.         (ok, i) = enter_range('\nEnter number 0...%d for device (q=quit) ?' % x, 0, x)
  382.     if ok:
  383.         ret = device_index[i]
  384.     
  385.     return ret
  386.  
  387.  
  388. def connection_table():
  389.     ret = None
  390.     ios = {
  391.         0: ('usb', 'Universal Serial Bus (USB)') }
  392.     x = 1
  393.     if prop.net_build:
  394.         ios[x] = ('net', 'Network/Ethernet/Wireless (direct connection or JetDirect)')
  395.         x += 1
  396.     
  397.     if prop.par_build:
  398.         ios[x] = ('par', 'Parallel Port (LPT:)')
  399.         x += 1
  400.     
  401.     if len(ios) > 1:
  402.         header('SELECT CONNECTION (I/O) TYPE')
  403.         table = Formatter(header = ('Num', 'Connection Type', 'Description'), max_widths = (8, 20, 80), min_widths = (8, 10, 40))
  404.         for x, data in ios.items():
  405.             if x == 0:
  406.                 table.add((str(x) + '*', data[0], data[1]))
  407.                 continue
  408.             table.add((str(x), data[0], data[1]))
  409.         
  410.         table.output()
  411.         (ok, val) = enter_range('\nEnter number 0...%d for connection type (q=quit, enter=usb*) ? ' % x, 0, x, 0)
  412.         if ok:
  413.             ret = [
  414.                 ios[val][0]]
  415.         
  416.     else:
  417.         ret = [
  418.             'usb']
  419.     return ret
  420.  
  421.